package com.zjcode.cdcer.utils;

import com.alibaba.fastjson.JSONObject;
import com.chinatechstar.component.commons.supports.PageData;
import com.chinatechstar.component.commons.utils.IdCardValidateUtils;
import com.chinatechstar.component.commons.utils.ValidateUtils;
import com.zjcode.cdcer.config.MConsts.Common;
import com.zjcode.cdcer.config.MConsts.SUB_DETAIL;
import com.zjcode.cdcer.model.*;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import org.apache.commons.collections4.map.HashedMap;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;

/**
 * @ClassName:Utils
 * @功能：通用工具
 * @author：wlei
 * @日期：2022/7/24-02:31
 **/
public class Utils {

    /**
     * 转换区域信息
     */
    public static PageData transitionRegionInfo(PageData pageData) {
        String regionCode = (String) pageData.get("regionCode");
        String cityCode = (String) pageData.get("cityCode");
        regionCode = Optional
            .ofNullable(regionCode)
            .orElse("");
        cityCode = Optional
            .ofNullable(cityCode)
            .orElse("");
        if (!StringUtils.isEmpty(cityCode)) {
            pageData.put("city_id", cityCode);
        }
        if (!StringUtils.isEmpty(regionCode)) {
            pageData.put("district_id", regionCode);
        }
        return pageData;
    }

    /**
     * 解析extflag2,并转换出子表展示状态
     *
     * @param extflag2
     * @return
     */
    public static Map<String, Boolean> parseExtFlag2(String extflag2) {
        Map<String, Boolean> result = new HashedMap<>();

        // 食管详情
        boolean sg = false;
        // 贲门详情
        boolean bm = false;
        // 胃详情
        boolean wd = false;

        String[] strings = extflag2.split("\\|");
        for (int i = 0; i < strings.length; i++) {
            String val = strings[i];
            if (i == 0) {
                sg = val.equals("1");
            } else if (i == 1) {
                bm = val.equals("1");
            } else if (i == 2) {
                wd = val.equals("1");
            }
        }

        result.put(SUB_DETAIL.SG, sg);
        result.put(SUB_DETAIL.BM, bm);
        result.put(SUB_DETAIL.WD, wd);

        return result;
    }

    /**
     * 检查是否高危
     *
     * @param info
     * @return
     */
    public static Map<String, Boolean> validateIsHighRisk(TkmSysteminitImportInfo info) {

        Map<String, Boolean> result = new HashedMap<>();

        // 食管详情
        boolean sg = false;
        // 贲门详情
        boolean bm = false;
        // 胃详情
        boolean wd = false;

        // 9种疾病
        List<String> bigProblems = Arrays.asList("食管癌前病变",
                                                 "食管低级别上皮内瘤变",
                                                 "食管高级别上皮内瘤变",
                                                 "早期食管癌",
                                                 "进展期食管癌",
                                                 "贲门前病变",
                                                 "贲门低级别上皮内瘤变",
                                                 "贲门高级别上皮内瘤变",
                                                 "早期贲门癌",
                                                 "进展期贲门癌",
                                                 "胃癌前病变",
                                                 "胃低级别上皮内瘤变",
                                                 "胃高级别上皮内瘤变",
                                                 "早期胃癌",
                                                 "进展期胃癌");
        String njzd = info.getNjzd();

        if (!StringUtils.isEmpty(njzd)) {
            if (njzd.contains(",")) {
                String[] strings = njzd.split(",");
                for (String each : strings) {
                    Optional<String> first = bigProblems
                        .stream()
                        .filter(s -> s.equals(each))
                        .findFirst();
                    if (first.isPresent()) {
                        String str = first.get();
                        if (!sg) {
                            //食管癌前病变,食管低级别上皮内瘤变,食管高级别上皮内瘤变,早期食管癌,进展期食管癌 sg=true
                            if (str.equals("食管癌前病变") || str.equals("食管低级别上皮内瘤变")
                                || str.equals("食管高级别上皮内瘤变") || str.equals("早期食管癌")
                                || str.equals("进展期食管癌")) {
                                sg = true;
                            }
                        }
                        if (!bm) {
                            //贲门前病变,贲门低级别上皮内瘤变,贲门高级别上皮内瘤变,早期贲门癌,进展期贲门癌 bm=true
                            if (str.equals("贲门前病变") || str.equals("贲门低级别上皮内瘤变")
                                || str.equals("贲门高级别上皮内瘤变") || str.equals("早期贲门癌")
                                || str.equals("进展期贲门癌")) {
                                bm = true;
                            }
                        }
                        if (!wd) {
                            //胃癌前病变,胃低级别上皮内瘤变,胃高级别上皮内瘤变,早期胃癌,进展期胃癌 wd=true
                            if (str.equals("胃癌前病变") || str.equals("胃低级别上皮内瘤变")
                                || str.equals("胃高级别上皮内瘤变") || str.equals("早期胃癌")
                                || str.equals("进展期胃癌")) {
                                wd = true;
                            }
                        }

                    }
                }
            } else {
                Optional<String> first = bigProblems
                    .stream()
                    .filter(s -> s.equals(njzd))
                    .findFirst();
                if (first.isPresent()) {
                    //食管癌前病变,食管低级别上皮内瘤变,食管高级别上皮内瘤变,早期食管癌,进展期食管癌 sg=true
                    if (njzd.equals("食管癌前病变") || njzd.equals("食管低级别上皮内瘤变")
                        || njzd.equals("食管高级别上皮内瘤变") || njzd.equals("早期食管癌")
                        || njzd.equals("进展期食管癌")) {
                        sg = true;
                    }
                    //贲门前病变,贲门低级别上皮内瘤变,贲门高级别上皮内瘤变,早期贲门癌,进展期贲门癌 bm=true
                    if (njzd.equals("贲门前病变") || njzd.equals("贲门低级别上皮内瘤变")
                        || njzd.equals("贲门高级别上皮内瘤变") || njzd.equals("早期贲门癌")
                        || njzd.equals("进展期贲门癌")) {
                        bm = true;
                    }
                    //胃癌前病变,胃低级别上皮内瘤变,胃高级别上皮内瘤变,早期胃癌,进展期胃癌 wd=true
                    if (njzd.equals("胃癌前病变") || njzd.equals("胃低级别上皮内瘤变")
                        || njzd.equals("胃高级别上皮内瘤变") || njzd.equals("早期胃癌")
                        || njzd.equals("进展期胃癌")) {
                        wd = true;
                    }
                }
            }


        }

        result.put(SUB_DETAIL.SG, sg);
        result.put(SUB_DETAIL.BM, bm);
        result.put(SUB_DETAIL.WD, wd);
        result.put(SUB_DETAIL.WD, wd);
        return result;

    }

    public static Boolean validateIsNeedTreatment(TkmSysteminitImportInfo info) {

        Boolean needTreatment =false;
        // 6种疾病
        List<String> bigProblems = Arrays.asList(
                "食管高级别上皮内瘤变",
                "早期食管癌",
                "贲门高级别上皮内瘤变",
                "早期贲门癌",
                "胃高级别上皮内瘤变",
                "早期胃癌");
        String njzd = info.getNjzd();

        if (!StringUtils.isEmpty(njzd)) {
            if (njzd.contains(",")) {
                String[] strings = njzd.split(",");
                for (String each : strings) {
                    Optional<String> first = bigProblems
                            .stream()
                            .filter(s -> s.equals(each))
                            .findFirst();
                    if (first.isPresent()) {
                        String str = first.get();
                        if (!needTreatment) {
                            //食管高级别上皮内瘤变,早期食管癌,贲门高级别上皮内瘤变,早期贲门癌,胃高级别上皮内瘤变,早期胃癌 needTreatment=true
                            if (str.equals("食管高级别上皮内瘤变") || str.equals("早期食管癌")
                                    || str.equals("贲门高级别上皮内瘤变") || str.equals("早期贲门癌")
                                    || str.equals("胃高级别上皮内瘤变")||str.equals("早期胃癌")) {
                                needTreatment = true;
                            }
                        }

                    }
                }
            } else {
                Optional<String> first = bigProblems
                        .stream()
                        .filter(s -> s.equals(njzd))
                        .findFirst();
                if (first.isPresent()) {
                    //食管高级别上皮内瘤变,早期食管癌,贲门高级别上皮内瘤变,早期贲门癌,胃高级别上皮内瘤变,早期胃癌 needTreatment=true
                    if (njzd.equals("食管高级别上皮内瘤变") || njzd.equals("早期食管癌")
                            || njzd.equals("贲门高级别上皮内瘤变") || njzd.equals("早期贲门癌")
                            || njzd.equals("胃高级别上皮内瘤变")||njzd.equals("早期胃癌")) {
                        needTreatment = true;
                    }
                }
            }


        }
        return needTreatment;

    }

    public static List<String> dataValidationByTreatmentInfo(CerTreatmentInfo info){
        List<String> errors = new ArrayList<>();
        // 联系人
        String contacts = info.getContacts();
        if (StringUtils.isEmpty(contacts)) {
            errors.add("联系人必填");
        }else{
            if (!isLetterOrChinese(contacts)) {
                errors.add("请正确填写姓名信息");
            }
        }
        // 关系
        String relationship = info.getRelationship();
        if (StringUtils.isEmpty(relationship)) {
            errors.add("关系必填");
        }else{
            if (!isChineseInput(relationship)) {
                errors.add("请正确填写关系信息");
            }
        }
        // 联系电话
        String telephone = info.getTelephone();
        if (StringUtils.isEmpty(telephone)) {
            errors.add("联系电话必填");
        }else{
            if (!ValidateUtils.checkMobile(telephone)) {
                errors.add("请正确填写联系电话信息");
            }
        }
        // 内镜检查
        String njjc = info.getNjjc();
        if (StringUtils.isEmpty(njjc)) {
            errors.add("内镜检查信息必选");
        }
        // 临床病例资料复印
        String caseFileDuplicate = info.getCaseFileDuplicate();
        if (StringUtils.isEmpty(caseFileDuplicate)) {
            errors.add("临床病例资料复印必选");
        }
        // 记录人
        String recorder = info.getRecorder();
        if (StringUtils.isEmpty(recorder)) {
            errors.add("记录人必选");
        }
        // 记录日期
        String recordDate = info.getRecordDate();
        if (StringUtils.isEmpty(recordDate)) {
            errors.add("记录日期必填");
        }else{
            if (!isDate(recordDate)) {
                // 不符合验证规则，自动将内镜诊疗日期设置为空值
                info.setRecordDate("");
                errors.add("记录日期必填");
//                errors.add("请填写正确的记录日期");
            }
        }
        return errors;
    }

    /**
     * 验证数据初始化数据是否合法
     *
     * @param info
     * @return
     */
    public static List<String> validateSysteminitImportInfoData(TkmSysteminitImportInfo info) {
        List<String> errors = new ArrayList<>();
        // 姓名
        String name = info.getName();
        if (StringUtils.isEmpty(name)) {
            errors.add("姓名必填");
        } else {
            if (!isLetterOrChinese(name)) {
                errors.add("请正确填写姓名信息");
            }
        }

        // 性别
        String sex = info.getSex();
        if (StringUtils.isEmpty(sex)) {
            errors.add("性别必填");
        }

      /*  // 年龄
        String age = info.getAge();
        if (StringUtils.isEmpty(age)) {
            errors.add("年龄必填");
        }*/

        // 身份证号
        String sfz = info.getSfz();
        if (StringUtils.isEmpty(sfz)) {
            errors.add("身份证号必填");
        } else {
            String message = IdCardValidateUtils.IDCardValidate(sfz);
            //if (!StringUtils.isEmpty(message) || sfz.length() != 18) {
            //    errors.add("请正确填写身份证号码");
            //}
            // todo: 身份证号码验证的正确判断方法备注销了,此处代码仅供测试时使用
            if (sfz.length() != 18) {
                errors.add("请正确填写身份证号码");
            }
        }

       /* // 门诊号
        String mzh = info.getMzh();
        // 住院号
        String zyh = info.getZyh();
        if (StringUtils.isEmpty(mzh) && StringUtils.isEmpty(zyh)) {
            errors.add("门诊或住院号必填");
        } else {
            if (!StringUtils.isEmpty(mzh) && !isLetterDigit(mzh)) {
                errors.add("请正确填写门诊或住院号");
            }
            if (!StringUtils.isEmpty(zyh) && !isLetterDigit(zyh)) {
                errors.add("请正确填写门诊或住院号");
            }
        }*/

        // 联系电话
        String phone = info.getPhone();
        if (!StringUtils.isEmpty(phone)) {
            if (!ValidateUtils.checkMobile(phone)) {
                errors.add("请正确填写联系电话信息");
            }
        } else {
            errors.add("请填写联系电话信息");
        }

     /*   // 对象来源
        String zldxLy = info.getZldxLy();
        if (StringUtils.isEmpty(zldxLy)) {
            errors.add("对象来源必填");
        }
*/
        // 是否无痛
        String ache = info.getAche();
        if (StringUtils.isEmpty(ache)) {
            errors.add("是否无痛必填");
        } else {
            if (Objects.equals(ache.trim(), "是")) {
                info.setAche("1");
            } else if (Objects.equals(ache.trim(), "否")) {
                info.setAche("2");
            } else if (!Objects.equals(ache.trim(), "1") && !Objects.equals(ache.trim(), "2")) {
                info.setAche("");
                errors.add("是否无痛必填");
            }
        }

        // 染色类别
        String dye = info.getDye();
        if (StringUtils.isEmpty(dye)) {
            errors.add("染色类别必填");
        } else {
            if (Objects.equals(dye.trim(), "未染")) {
                info.setDye("0");
            } else if (Objects.equals(dye.trim(), "碘染色")) {
                info.setDye("1");
            }  else if (Objects.equals(dye.trim(), "靛胭脂染色")) {
                info.setDye("2");
            }  else if (Objects.equals(dye.trim(), "电子增强（包括NBI或FICE或iSCAN）") || Objects.equals(dye.trim(), "电子增强(包括NBI或FICE或iSCAN)")) {
                info.setDye("3");
            }  else if (Objects.equals(dye.trim(), "碘染色+靛胭脂染色")) {
                info.setDye("4");
            }  else if (Objects.equals(dye.trim(), "靛胭脂染色+电子增强")) {
                info.setDye("5");
            }  else if (Objects.equals(dye.trim(), "碘染色+电子增强")) {
                info.setDye("6");
            }  else if (Objects.equals(dye.trim(), "碘染色+靛胭脂染色+电子增强")) {
                info.setDye("7");
            }  else if (!Objects.equals(dye.trim(), "0") && !Objects.equals(dye.trim(), "1")
                    && !Objects.equals(dye.trim(), "2")&& !Objects.equals(dye.trim(), "3")
                    && !Objects.equals(dye.trim(), "4")&& !Objects.equals(dye.trim(), "5")
                    && !Objects.equals(dye.trim(), "6")&& !Objects.equals(dye.trim(), "7")) {
                info.setDye("");
                errors.add("染色类别必填");
            }
        }

        // 内镜号
        String njNum = info.getNjNum();
        if (StringUtils.isEmpty(njNum)) {
            errors.add("内镜号必填");
        } else {
            if (!ValidateUtils.checkNumAndLetter(njNum) && !StringUtils.isNumeric(njNum)) {
                errors.add("请正确填写内镜号");
            }
        }

        // 图像数据量
        String picNums = info.getPicNums();
        if (StringUtils.isEmpty(picNums)) {
            errors.add("图像数据量必填");
        } else {
            int anInt = Integer.parseInt(picNums);
            if (anInt < 1 || anInt > 300) {
                errors.add("图像数据应在1-300之间");
            }
        }

        // 是否活检
        String isHj = info.getIsHj();
        if (StringUtils.isEmpty(isHj)) {
            errors.add("是否活检必填");
        } else {
            if (Objects.equals(isHj.trim(), "是")) {
                info.setIsHj("1");
            } else if (Objects.equals(isHj.trim(), "否")) {
                info.setIsHj("2");
            } else if (!Objects.equals(isHj.trim(), "1") && !Objects.equals(isHj.trim(), "2")) {
                info.setIsHj("");
                errors.add("是否活检必填");
            }
        }

        // Hp检测结果
        String hp = info.getHp();
        if (StringUtils.isEmpty(hp)) {
            errors.add("Hp必填");
        } else {
            if (Objects.equals(hp.trim(), "未做")) {
                info.setHp("0");
            } else if (Objects.equals(hp.trim(), "阳性")) {
                info.setHp("1");
            } else if (Objects.equals(hp.trim(), "阴性")) {
                info.setHp("2");
            } else if (!Objects.equals(hp.trim(), "1") && !Objects.equals(hp.trim(), "2") && !Objects.equals(hp.trim(),"0")) {
                info.setHp("");
                errors.add("请正确填写Hp");
            }
            //else {
            //    info.setHp("");
            //    errors.add("Hp必填");
            //}
        }

        // Hp检测方法
        String hpjcjg = info.getHpjcjg();
        if (StringUtils.isEmpty(hpjcjg)) {
            if (StringUtils.isEmpty(hp)){
                errors.add("请正确填写Hp检测方法");
            }
        } else {
            //1=快速尿素酶
            //2=C13呼气试验
            //3=C14呼气试验
            //4=血清Hp抗体
            //5=病理诊断
            if (StringUtils.isNotEmpty(hp) && ( Objects.equals(hp, "未做")|| Objects.equals(hp, "0"))){
                info.setHpjcjg("");
                errors.add("请正确填写Hp或HP检测方法");
            }else{
                if (Objects.equals(hpjcjg.trim(), "快速尿素酶")) {
                    info.setHpjcjg("1");
                } else if (Objects.equals(hpjcjg.trim(), "C13呼气试验")) {
                    info.setHpjcjg("2");
                } else if (Objects.equals(hpjcjg.trim(), "C14呼气试验")) {
                    info.setHpjcjg("3");
                } else if (Objects.equals(hpjcjg.trim(), "血清Hp抗体")) {
                    info.setHpjcjg("4");
                } else if (Objects.equals(hpjcjg.trim(), "病理诊断")) {
                    info.setHpjcjg("5");
                } else if (!Objects.equals(hpjcjg.trim(), "1") && !Objects.equals(hpjcjg.trim(), "2")
                        && !Objects.equals(hpjcjg.trim(), "3")&& !Objects.equals(hpjcjg.trim(), "4")
                        && !Objects.equals(hpjcjg.trim(), "5")) {
                    info.setHpjcjg("");
                    errors.add("请正确填写Hp检测方法");
                }
            }
        }

      /*  // 诊疗方式
        String zlFs = info.getZlFs();
        if (StringUtils.isEmpty(zlFs)) {
            errors.add("诊疗方式不能为空");
        } else {
            //1.首诊
            //2.复查
            //3.其他
            if (Objects.equals(zlFs, "首诊")) {
                info.setZlFs("1");
            } else if (Objects.equals(zlFs, "复查")) {
                info.setZlFs("2");
            } else if (Objects.equals(zlFs, "其他")) {
                info.setZlFs("3");
            } else if (!Objects.equals(zlFs, "1") && !Objects.equals(zlFs, "2") && !Objects.equals(
                zlFs,
                "3")) {
                info.setZlFs("");
                errors.add("诊疗方式不能为空");
            }
        }*/

        // 内镜诊断医师
        String njStaff = info.getNjStaff();
        if (StringUtils.isEmpty(njStaff)) {
            errors.add("内镜诊断医师必填");
        }

        // 内镜诊疗日期
        String njzlTime = info.getNjzlTime();
        if (StringUtils.isEmpty(njzlTime)) {
            errors.add("内镜诊疗日期必填");
        } else {
            if (!isDate(njzlTime)) {
                // 不符合验证规则，自动将内镜诊疗日期设置为空值
                info.setNjzlTime("");
                errors.add("内镜诊疗日期必填");
            }
        }

        // 内镜诊断
        String njzd = info.getNjzd();
        if (StringUtils.isEmpty(njzd)) {
            errors.add("内镜诊断必填");
        }

        // 是否活检：is_hj为‘2'(否)时，所有病理判断去除
        String hj = info.getIsHj();
        if (ObjectUtils.isEmpty(hj)|| Objects.equals(hj.trim(),"1")) {
            // 病理号
            String blNum = info.getBlNum();
            if (StringUtils.isEmpty(blNum)) {
                errors.add("病理号不能为空");
            } else if (!ValidateUtils.checkNumAndLetter(blNum)) {
                errors.add("病理号只能是数字和字母");
            }

            // 病理诊断医师
            String blzdStaff = info.getBlzdStaff();
            if (StringUtils.isEmpty(blzdStaff)) {
                errors.add("病理诊断医师不能为空");
            }

            // 病理报告日期
            String blbgTime = info.getBlbgTime();
            if (StringUtils.isEmpty(blbgTime)) {
                //errors.add("病理报告日期不能为空");
            } else {
                if (!isDate(blbgTime)) {
                    // 不符合验证规则，自动将病理报告日期设置为空值
                    info.setBlbgTime("");
                }
            }

            // 病理诊断
            String blzd = info.getBlzd();
            if (StringUtils.isEmpty(blzd)) {
                errors.add("病理诊断不能为空");
            }

            String sgblCode = info.getSgblCode();
            String bmblCode = info.getBmblCode();
            String zlblCode = info.getWblCode();
            String sezcCode = info.getSezcCode();
            if ("1".equals(isHj)) {
                if (StringUtils.isEmpty(sgblCode) && StringUtils.isEmpty(bmblCode)
                        && StringUtils.isEmpty(zlblCode) && StringUtils.isEmpty(sezcCode)) {
                    errors.add("请正确填写病理诊断代码");
                }
            }

            String blReportFilePath = info.getBlReportFilePath();
            if(StringUtils.isEmpty(blReportFilePath)){
                errors.add("病理报告单必须上传");
            }else{
                if (!FileTypeFormat1(blReportFilePath)){
                    errors.add("病理报告单必须是JPG,PNG,PDF格式");
                }
            }

        }

        //风险因素自测表
        String riskReportId = info.getRiskReportId();
        if(StringUtils.isEmpty(riskReportId)){
            errors.add("未关联风险因素自测表");
        }
        String reportFileUrl = info.getReportFileUrl();
        if(StringUtils.isEmpty(reportFileUrl)){
            errors.add("内镜报告单必须上传");
        }else {
            if (!FileTypeFormat1(reportFileUrl)){
                errors.add("内镜报告单必须是JPG,PNG,PDF格式");
            }
        }
        String writtenConsentFilePath = info.getWrittenConsentFilePath();
        if(StringUtils.isEmpty(writtenConsentFilePath)){
            errors.add("知情同意书必须上传");
        }else {
            if (!FileTypeFormat1(writtenConsentFilePath)){
                errors.add("知情同意书必须是JPG,PNG,PDF格式");
            }
        }
        // 验证详情
  /*      errors.addAll(validateSgData(sg));
        errors.addAll(validateBmData(bm));
        errors.addAll(validateWData(w));*/

        return errors;
    }

    private static Boolean FileTypeFormat1(String filePath) {
        if (filePath.indexOf("jpg") != -1 ||
                filePath.indexOf("png") != -1 ||
                filePath.indexOf("pdf") != -1) {
            return true;
        } else return false;

    }

    public static List<String> validateCerPersonalInfoData(CerPersonalInfo info) {
        List<String> errors = new ArrayList<>();
        // 姓名
        String name = info.getName();
        if (StringUtils.isEmpty(name)) {
            errors.add("姓名必填");
        } else {
            if (!isLetterOrChinese(name)) {
                errors.add("请正确填写姓名信息");
            }
        }

        // 性别
        String sex = info.getSex();
        if (StringUtils.isEmpty(sex)) {
            errors.add("性别必填");
        }


        // 身份证号
        String sfz = info.getIdCard();
        if (StringUtils.isEmpty(sfz)) {
            errors.add("身份证号必填");
        } else {
            String message = IdCardValidateUtils.IDCardValidate(sfz);
            //if (!StringUtils.isEmpty(message) || sfz.length() != 18) {
            //    errors.add("请正确填写身份证号码");
            //}
            // todo: 身份证号码验证的正确判断方法备注销了,此处代码仅供测试时使用
            if (sfz.length() != 18) {
                errors.add("请正确填写身份证号码");
            }
        }


        // 联系电话
        String phone = info.getPhone();
        if (!StringUtils.isEmpty(phone)) {
            if (!ValidateUtils.checkMobile(phone)) {
                errors.add("请正确填写联系电话信息");
            }
        } else {
            errors.add("请填写联系电话信息");
        }
        //省getProvinceName())
        //getDistrictName())
        //getCityName())
        //getCountyName())
        //getVillageName())
        //getSex())
        //getNationCode())
        //getPhone())
        //getBirthday()))
        String provinceName = info.getProvinceName();
        if (StringUtils.isEmpty(provinceName)) {
            errors.add("省必填");
        }
        String cityName = info.getCityName();
        if (StringUtils.isEmpty(cityName)) {
            errors.add("城市必填");
        }
        String districtName = info.getDistrictName();
        if (StringUtils.isEmpty(districtName)) {
            errors.add("区县必填");
        }
        String countyName = info.getCountyName();
        if (StringUtils.isEmpty(countyName)) {
            errors.add("乡镇必填");
        }
        String villageName = info.getVillageName();
        if (StringUtils.isEmpty(villageName)) {
            errors.add("村必填");
        }
        String nationCode = info.getNationCode();
        if (StringUtils.isEmpty(nationCode)) {
            errors.add("民族必填");
        }
        String birthday = info.getBirthday();
        if (StringUtils.isEmpty(birthday)) {
            errors.add("出生日期必填");
        }
        return errors;
    }


    /**
     * 验证详情数据上报数据是否合法
     *
     * @param info
     * @return
     */
    public static List<String> validateDetailImportInfoData(CerDetaildataImportInfo info,
                                                            Object sg,
                                                            Object bm,
                                                            Object w) {
        List<String> errors = new ArrayList<>();
        // 姓名
        String name = info.getName();
        if (StringUtils.isEmpty(name)) {
            errors.add("姓名必填");
        } else {
            if (!isLetterOrChinese(name)) {
                errors.add("请正确填写姓名信息");
            }
        }

        // 性别
        String sex = info.getSex();
        if (StringUtils.isEmpty(sex)) {
            errors.add("性别必填");
        }

        // 年龄
        String age = info.getAge() == null ? "" : info
            .getAge()
            .toString();
        if (StringUtils.isEmpty(age)) {
            errors.add("年龄必填");
        }

        // 身份证号
        String sfz = info.getSfz();
        if (StringUtils.isEmpty(sfz)) {
            errors.add("身份证号必填");
        } else {
            String message = IdCardValidateUtils.IDCardValidate(sfz);
            //if (!StringUtils.isEmpty(message) || sfz.length() != 18) {
            //    errors.add("请正确填写身份证号码");
            //}
            // todo: 身份证号码验证的正确判断方法备注销了,此处代码仅供测试时使用
            if (sfz.length() != 18) {
                errors.add("请正确填写身份证号码");
            }
        }

        // 门诊号
        String mzh = info.getMzh();
        // 住院号
        String zyh = info.getZyh();
        if (StringUtils.isEmpty(mzh) && StringUtils.isEmpty(zyh)) {
            errors.add("门诊或住院号必填");
        } else {
            if (!StringUtils.isEmpty(mzh) && !isLetterDigit(mzh)) {
                errors.add("请正确填写门诊或住院号");
            }
            if (!StringUtils.isEmpty(zyh) && !isLetterDigit(zyh)) {
                errors.add("请正确填写门诊或住院号");
            }
        }

        // 联系电话
        String phone = info.getPhone();
        if (!StringUtils.isEmpty(phone)) {
            if (!ValidateUtils.checkMobile(phone)) {
                errors.add("请正确填写联系电话信息");
            }
        }

        // 诊疗方式
        String zlFs = info.getZlFs();
        if (StringUtils.isEmpty(zlFs)) {
            errors.add("诊疗方式不能为空");
        }

        // 对象来源
        String zldxLy = info.getZldxLy();
        if (StringUtils.isEmpty(zldxLy)) {
            errors.add("对象来源必填");
        }

        // 是否无痛
        String ache = info.getAche();
        if (StringUtils.isEmpty(ache)) {
            errors.add("是否无痛必填");
        }

        // 染色类别
        String dye = info.getDye();
        if (StringUtils.isEmpty(dye)) {
            errors.add("染色类别必填");
        }

        // 内镜号
        String njNum = info.getNjNum();
        if (StringUtils.isEmpty(njNum)) {
            errors.add("内镜号必填");
        } else {
            if (!ValidateUtils.checkNumAndLetter(njNum) && !StringUtils.isNumeric(njNum)) {
                errors.add("请正确填写内镜号");
            }
        }

        // 图像数据量
        String picNums = info.getPicNums();
        if (StringUtils.isEmpty(picNums)) {
            errors.add("图像数据量必填");
        } else {
            int anInt = Integer.parseInt(picNums);
            if (anInt < 1 || anInt > 300) {
                errors.add("图像数据应在1-300之间");
            }
        }

        // 是否活检
        String isHj = info.getIsHj();
        if (StringUtils.isEmpty(isHj)) {
            errors.add("是否活检必填");
        }

        // Hp加测结果
        String hp = info.getHp();
        if (StringUtils.isEmpty(hp)) {
            errors.add("Hp必填");
        }

        // Hp检测方法
        String hpjcjg = info.getHpjcjg();
        if (StringUtils.isEmpty(hpjcjg)) {
            errors.add("请正确填写Hp或Hp检测方法");
        }

        // 内镜诊断医师
        String njStaff = info.getNjStaff();
        if (StringUtils.isEmpty(njStaff)) {
            errors.add("内镜诊断医师必填");
        }

        // 病理号
        String blNum = info.getBlNum();
        if (StringUtils.isEmpty(blNum)) {
            errors.add("病理号不能为空");
        } else if (!ValidateUtils.checkNumAndLetter(blNum)) {
            errors.add("病理号只能是数字和字母");
        }

        // 病理诊断医师
        String blzdStaff = info.getBlzdStaff();
        if (StringUtils.isEmpty(blzdStaff)) {
            errors.add("病理诊断医师不能为空");
        }

        // 内镜诊疗日期
        String njzlTime = info.getNjzlTime();
        if (StringUtils.isEmpty(njzlTime)) {
            errors.add("内镜诊疗日期必填");
        }

        // 病理诊断
        String blzd = info.getBlzd();
        if (StringUtils.isEmpty(blzd)) {
            errors.add("病理诊断不能为空");
        }

        // 内镜诊断

        String njzd = info.getNjzd();
        if (StringUtils.isEmpty(njzd)) {
            errors.add("内镜诊断必填");
        }

        String sgblCode = info.getSgblCode();
        String bmblCode = info.getBmblCode();
        String zlblCode = info.getWblCode();
        String sezcCode = info.getSezcCode();
        if ("1".equals(isHj)) {
            if (StringUtils.isEmpty(sgblCode) && StringUtils.isEmpty(bmblCode)
                && StringUtils.isEmpty(zlblCode) && StringUtils.isEmpty(sezcCode)) {
                errors.add("请正确填写病理诊断代码");
            }
        }

        // 最高诊断代码
        String extFlag2 = getExtFlag2(info);

        if (!"0|0|0".equals(extFlag2) && StringUtils.isEmpty(info.getReportFileUrl())) {
            errors.add("内镜报告单必须上传");
        }

        if (!"0|0|0".equals(extFlag2)) {
            // 需要上报内镜详情
            int status1 = getHjStatus(sg);
            int status2 = getHjStatus(bm);
            int status3 = getHjStatus(w);
            int sum = status1 + status2 + status3;
            if (sum > 0 && StringUtils.isEmpty(info.getBlReportFileUrl())) {
                errors.add("病理报告单必须上传");
            }
            if (sum > 0) {
                // 病理审核医师
                String blshStaff = info.getBlshStaff();
                // 病理报告日期
                String blbgTime = info.getBlbgTime();
                if (StringUtils.isEmpty(blshStaff) || StringUtils.isEmpty(blbgTime)) {
                    errors.add("请完善病理信息");
                }
            }
        }

        // 验证详情
        errors.addAll(validateSgData(sg));
        errors.addAll(validateBmData(bm));
        errors.addAll(validateWData(w));

        return errors;
    }

    /**
     * 验证数据内镜诊断数据是否合法  食管
     *
     * @param list
     * @return
     */
    public static List<String> validateSgData(List<CerEndoscopicDiagnosisDetails> list) {
        List<String> errors = new ArrayList<>();
        if (!CollectionUtils.isEmpty(list)) {
            list
                .parallelStream()
                .forEach(item -> {
                    if (StringUtils.isEmpty(item.getJlStart())
                        || StringUtils.isEmpty(item.getJlEnd())
                        || StringUtils.isEmpty(item.getDwStart())
                        || StringUtils.isEmpty(item.getDwEnd())
                        || StringUtils.isEmpty(item.getFxCode())
                        || StringUtils.isEmpty(item.getFxVal()) || item.getIsHj() == null
                        || StringUtils.isEmpty(item.getHjNum())
                        || StringUtils.isEmpty(item.getSgWJl())) {
                        errors.add("请将食管详情填写完整");
                    }
                });
        }
        return errors;
    }

    /**
     * 验证数据内镜诊断数据是否合法  贲门
     *
     * @param list
     * @return
     */
    public static List<String> validateBmData(List<CerEndoscopicDiagnosisDetails> list) {
        List<String> errors = new ArrayList<>();
        if (!CollectionUtils.isEmpty(list)) {
            list
                .parallelStream()
                .forEach(item -> {
                    if (StringUtils.isEmpty(item.getBbwzStart())
                        || StringUtils.isEmpty(item.getBbwzEnd())
                        || StringUtils.isEmpty(item.getJlStart())
                        || StringUtils.isEmpty(item.getJlEnd()) || StringUtils.isEmpty(item.getFx())
                        || StringUtils.isEmpty(item.getFxCode())
                        || StringUtils.isEmpty(item.getFxVal()) || item.getIsHj() == null
                        || StringUtils.isEmpty(item.getHjNum())) {
                        errors.add("请将贲门详情填写完整");
                    }
                });
        }
        return errors;
    }

    /**
     * 验证数据内镜诊断数据是否合法  胃
     *
     * @param list
     * @return
     */
    public static List<String> validateWData(List<CerEndoscopicDiagnosisDetails> list) {
        List<String> errors = new ArrayList<>();
        if (!CollectionUtils.isEmpty(list)) {
            list
                .parallelStream()
                .forEach(item -> {
                    if (StringUtils.isEmpty(item.getBbwzStart())
                        || StringUtils.isEmpty(item.getBbwzEnd())
                        || StringUtils.isEmpty(item.getJlStart())
                        || StringUtils.isEmpty(item.getJlEnd()) || StringUtils.isEmpty(item.getFx())
                        || StringUtils.isEmpty(item.getFxCode())
                        || StringUtils.isEmpty(item.getFxVal()) || item.getIsHj() == null
                        || StringUtils.isEmpty(item.getHjNum())) {
                        errors.add("请将胃详情填写完整");
                    }
                });
        }
        return errors;
    }

    /**
     * 验证食管数据
     *
     * @param sg
     * @return
     */
    public static List<String> validateSgData(Object sg) {
        if (sg == null) {
            return new ArrayList<>();
        }
        String str = sg.toString();
        List<CerEndoscopicDiagnosisDetails> list = JSONObject.parseArray(str,
                                                                         CerEndoscopicDiagnosisDetails.class);
        return validateSgData(list);
    }

    /**
     * 验证贲门
     *
     * @param sg
     * @return
     */
    public static List<String> validateBmData(Object sg) {
        if (sg == null) {
            return new ArrayList<>();
        }
        String str = sg.toString();
        List<CerEndoscopicDiagnosisDetails> list = JSONObject.parseArray(str,
                                                                         CerEndoscopicDiagnosisDetails.class);
        return validateBmData(list);
    }

    /**
     * 验证胃数据
     *
     * @param sg
     * @return
     */
    public static List<String> validateWData(Object sg) {
        if (sg == null) {
            return new ArrayList<>();
        }
        String str = sg.toString();
        List<CerEndoscopicDiagnosisDetails> list = JSONObject.parseArray(str,
                                                                         CerEndoscopicDiagnosisDetails.class);
        return validateWData(list);
    }

    /**
     * 校验中文数字英文
     *
     * @param str
     * @return
     */
    private static boolean isLetterDigitOrChinese(String str) {
        String regex = "^[a-z0-9A-Z\u4e00-\u9fa5]+$";
        return str.matches(regex);
    }

    /**
     * 校验中文英文
     *
     * @param str
     * @return
     */
    private static boolean isLetterOrChinese(String str) {
        String regex = "^[a-z0-9A-Z\u4e00-\u9fa5]+$";
        return str.matches(regex);
    }

    /**
     * 校验中文
     * @param input
     * @return
     */
    private static boolean isChineseInput(String input) {
        String pattern = "[\\u4e00-\\u9fa5]+";
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(input);
        return m.matches();
    }

    /**
     * 验证纯数字或英文
     *
     * @param str
     * @return
     */
    private static boolean isLetterDigit(String str) {
        String regex = "^[a-z0-9A-Z]+$";
        return str.matches(regex);
    }

    /**
     * 将Object转换成List类型
     *
     * @param obj   Object对象
     * @param clazz 数据类型
     * @param <T>   泛型类型
     * @return 转换结果
     */
    public static <T> List<T> castToList(Object obj, Class<T> clazz) {
        List<T> result = new ArrayList<>();
        // 如果不是List<?>对象，是没有办法转换的
        if (obj instanceof List<?>) {
            for (Object o : (List<?>) obj) {
                // 根据业务需要来决定这里要不要将null值还原放进去
                if (o == null) {
                    result.add(clazz.cast(null));
                    continue;
                }
                // 转换前的前置判断，避免clazz.cast的时候出现类转换异常
                if (o.getClass().equals(clazz)) {
                    // 将对应的元素进行类型转换
                    result.add(clazz.cast(o));
                }
            }
            return result;
        }
        return result;
    }

    /**
     * 获取Extflag2的值
     *
     * @param target
     * @return
     */
    private static String getExtFlag2(CerDetaildataImportInfo target) {
        List<Integer> flags = new ArrayList<>();
        // 获取食管病理诊断代码
        String sgblCode = target.getSgblCode();
        flags.add(getFlagByCode(sgblCode));
        // 获取贲门病理诊断代码
        String bmblCode = target.getBmblCode();
        flags.add(getFlagByCode(bmblCode));
        // 获取胃病理诊断代码
        String wblCode = target.getWblCode();
        flags.add(getFlagByCode(wblCode));
        String extFlag2 = flags
            .stream()
            .map(String::valueOf)
            .collect(Collectors.joining(Common.DELIMITER_CHARACTER));
        return extFlag2;
    }

    private static int getFlagByCode(String code) {
        if (StringUtils.isEmpty(code)) {
            return 0;
        }
        long count = Common.DIAGNOSTIC_CODE_LIST
            .stream()
            .filter(c -> {
                return c.equals(code);
            })
            .count();
        if (count > 0) {
            return 1;
        }
        return 0;
    }

    /**
     * 从详情中获取是否需要活检,1需要活检,0不需要活检
     *
     * @param detail
     * @return
     */
    private static int getHjStatus(Object detail) {
        if (detail == null) {
            return 0;
        }
        String str = detail.toString();
        List<CerEndoscopicDiagnosisDetails> list = JSONObject.parseArray(str,
                                                                         CerEndoscopicDiagnosisDetails.class);

        if (list == null) {
            return 0;
        }

        int sum = list
            .stream()
            .mapToInt(value -> {
                if (value == null) {
                    return 0;
                }
                return value.getIsHj() == null ? 0 : value.getIsHj();
            })
            .sum();

        return sum > 0 ? 1 : 0;
    }

    /**
     * 转换存储胃镜诊疗总量详情
     *
     * @param info, obj
     * @return
     */
    public static Map<String, Object> saveDiagnosisInfo(List<TkmGastroscopeDiagnosisInfo> info,
                                                        LinkedHashMap<String, Object> obj) {
        Map<String, Object> hashMap = new HashMap<>();
        List<LinkedHashMap<String, Object>> list = new ArrayList<>();
        if (!CollectionUtils.isEmpty(info) && !CollectionUtils.isEmpty(obj)) {
            info
                .stream()
                .forEach(each -> {
                    LinkedHashMap<String, Object> map = new LinkedHashMap<>();
                    String uploadMonth = each
                        .getUploadMonth()
                        .toString();
                    if (uploadMonth.equals("1")) {
                        Object janCount1 = obj.get("jan_count");
                        if (Objects.nonNull(janCount1)) {
                            //一月份的总数
                            map.put("count", janCount1.toString());
                        }
                        Object envienceFileUrl1 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl1)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl1.toString());
                        }
                        Integer auditStatus1 = each.getAuditStatus();
                        if (auditStatus1 != null) {
                            //是否审核
                            switch (auditStatus1) {
                                case 1:
                                    map.put("auditStatusCn", "审核通过");
                                    break;
                                case 2:
                                    map.put("auditStatusCn", "审核不通过");
                                    break;
                                case 0:
                                default:
                                    map.put("auditStatusCn", "未审核");
                                    break;
                            }
                        }
                        map.put("uploadMonthText", "一月份");
                        map.put("auditStatus", auditStatus1);
                    }
                    if (uploadMonth.equals("2")) {
                        Object janCount2 = obj.get("feb_count");
                        if (Objects.nonNull(janCount2)) {
                            //一月份的总数
                            map.put("count", janCount2.toString());
                        }
                        Object envienceFileUrl2 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl2)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl2.toString());
                        }
                        Integer auditStatus2 = each.getAuditStatus();
                        if (auditStatus2 != null) {
                            //是否审核
                            switch (auditStatus2) {
                                case 1:
                                    map.put("auditStatusCn", "审核通过");
                                    break;
                                case 2:
                                    map.put("auditStatusCn", "审核不通过");
                                    break;
                                case 0:
                                default:
                                    map.put("auditStatusCn", "未审核");
                                    break;
                            }
                        }
                        map.put("uploadMonthText", "二月份");
                        map.put("auditStatus", auditStatus2);
                    }
                    if (uploadMonth.equals("3")) {
                        Object janCount3 = obj.get("mar_count");
                        if (Objects.nonNull(janCount3)) {
                            //一月份的总数
                            map.put("count", janCount3.toString());
                        }
                        Object envienceFileUrl3 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl3)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl3.toString());
                        }
                        Integer auditStatus3 = each.getAuditStatus();
                        //是否审核
                        switch (auditStatus3) {
                            case 1:
                                map.put("auditStatusCn", "审核通过");
                                break;
                            case 2:
                                map.put("auditStatusCn", "审核不通过");
                                break;
                            case 0:
                            default:
                                map.put("auditStatusCn", "未审核");
                                break;
                        }
                        map.put("uploadMonthText", "三月份");
                        map.put("auditStatus", auditStatus3);
                    }
                    if (uploadMonth.equals("4")) {
                        Object janCount4 = obj.get("apr_count");
                        if (Objects.nonNull(janCount4)) {
                            //一月份的总数
                            map.put("count", janCount4.toString());
                        }
                        Object envienceFileUrl4 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl4)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl4.toString());
                        }
                        Integer auditStatus4 = each.getAuditStatus();
                        //是否审核
                        switch (auditStatus4) {
                            case 1:
                                map.put("auditStatusCn", "审核通过");
                                break;
                            case 2:
                                map.put("auditStatusCn", "审核不通过");
                                break;
                            case 0:
                            default:
                                map.put("auditStatusCn", "未审核");
                                break;
                        }
                        map.put("uploadMonthText", "四月份");
                        map.put("auditStatus", auditStatus4);
                    }
                    if (uploadMonth.equals("5")) {
                        Object janCount5 = obj.get("may_count");
                        if (Objects.nonNull(janCount5)) {
                            //一月份的总数
                            map.put("count", janCount5.toString());
                        }
                        Object envienceFileUrl5 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl5)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl5.toString());
                        }
                        Integer auditStatus5 = each.getAuditStatus();
                        //是否审核
                        switch (auditStatus5) {
                            case 1:
                                map.put("auditStatusCn", "审核通过");
                                break;
                            case 2:
                                map.put("auditStatusCn", "审核不通过");
                                break;
                            case 0:
                            default:
                                map.put("auditStatusCn", "未审核");
                                break;
                        }
                        map.put("uploadMonthText", "五月份");
                        map.put("auditStatus", auditStatus5);
                    }
                    if (uploadMonth.equals("6")) {
                        Object janCount6 = obj.get("jun_count");
                        if (Objects.nonNull(janCount6)) {
                            //一月份的总数
                            map.put("count", janCount6.toString());
                        }
                        Object envienceFileUrl6 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl6)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl6.toString());
                        }
                        Integer auditStatus6 = each.getAuditStatus();
                        //是否审核
                        switch (auditStatus6) {
                            case 1:
                                map.put("auditStatusCn", "审核通过");
                                break;
                            case 2:
                                map.put("auditStatusCn", "审核不通过");
                                break;
                            case 0:
                            default:
                                map.put("auditStatusCn", "未审核");
                                break;
                        }
                        map.put("uploadMonthText", "六月份");
                        map.put("auditStatus", auditStatus6);
                    }
                    if (uploadMonth.equals("7")) {
                        Object janCount7 = obj.get("jul_count");
                        if (Objects.nonNull(janCount7)) {
                            //一月份的总数
                            map.put("count", janCount7.toString());
                        }
                        Object envienceFileUrl7 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl7)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl7.toString());
                        }
                        Integer auditStatus7 = each.getAuditStatus();
                        //是否审核
                        switch (auditStatus7) {
                            case 1:
                                map.put("auditStatusCn", "审核通过");
                                break;
                            case 2:
                                map.put("auditStatusCn", "审核不通过");
                                break;
                            case 0:
                            default:
                                map.put("auditStatusCn", "未审核");
                                break;
                        }
                        map.put("uploadMonthText", "七月份");
                        map.put("auditStatus", auditStatus7);
                    }
                    if (uploadMonth.equals("8")) {
                        Object janCount8 = obj.get("aug_count");
                        if (Objects.nonNull(janCount8)) {
                            //一月份的总数
                            map.put("count", janCount8.toString());
                        }
                        Object envienceFileUrl8 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl8)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl8.toString());
                        }
                        Integer auditStatus8 = each.getAuditStatus();
                        //是否审核
                        switch (auditStatus8) {
                            case 1:
                                map.put("auditStatusCn", "审核通过");
                                break;
                            case 2:
                                map.put("auditStatusCn", "审核不通过");
                                break;
                            case 0:
                            default:
                                map.put("auditStatusCn", "未审核");
                                break;
                        }
                        map.put("uploadMonthText", "八月份");
                        map.put("auditStatus", auditStatus8);
                    }
                    if (uploadMonth.equals("9")) {
                        Object janCount9 = obj.get("sept_count");
                        if (Objects.nonNull(janCount9)) {
                            //一月份的总数
                            map.put("count", janCount9.toString());
                        }
                        Object envienceFileUrl9 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl9)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl9.toString());
                        }
                        Integer auditStatus9 = each.getAuditStatus();
                        //是否审核
                        switch (auditStatus9) {
                            case 1:
                                map.put("auditStatusCn", "审核通过");
                                break;
                            case 2:
                                map.put("auditStatusCn", "审核不通过");
                                break;
                            case 0:
                            default:
                                map.put("auditStatusCn", "未审核");
                                break;
                        }
                        map.put("uploadMonthText", "九月份");
                        map.put("auditStatus", auditStatus9);
                    }
                    if (uploadMonth.equals("10")) {
                        Object janCount10 = obj.get("oct_count");
                        if (Objects.nonNull(janCount10)) {
                            //一月份的总数
                            map.put("count", janCount10.toString());
                        }
                        Object envienceFileUrl10 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl10)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl10.toString());
                        }
                        Integer auditStatus10 = each.getAuditStatus();
                        //是否审核
                        switch (auditStatus10) {
                            case 1:
                                map.put("auditStatusCn", "审核通过");
                                break;
                            case 2:
                                map.put("auditStatusCn", "审核不通过");
                                break;
                            case 0:
                            default:
                                map.put("auditStatusCn", "未审核");
                                break;
                        }
                        map.put("uploadMonthText", "十月份");
                        map.put("auditStatus", auditStatus10);
                    }
                    if (uploadMonth.equals("11")) {
                        Object janCount11 = obj.get("nov_count");
                        if (Objects.nonNull(janCount11)) {
                            //一月份的总数
                            map.put("count", janCount11.toString());
                        }
                        Object envienceFileUrl11 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl11)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl11.toString());
                        }
                        Integer auditStatus11 = each.getAuditStatus();
                        //是否审核
                        switch (auditStatus11) {
                            case 1:
                                map.put("auditStatusCn", "审核通过");
                                break;
                            case 2:
                                map.put("auditStatusCn", "审核不通过");
                                break;
                            case 0:
                            default:
                                map.put("auditStatusCn", "未审核");
                                break;
                        }
                        map.put("uploadMonthText", "十一月份");
                        map.put("auditStatus", auditStatus11);
                    }
                    if (uploadMonth.equals("12")) {
                        Object janCount12 = obj.get("dec_count");
                        if (Objects.nonNull(janCount12)) {
                            //一月份的总数
                            map.put("count", janCount12.toString());
                        }
                        Object envienceFileUrl12 = each.getEnvienceFileUrl();
                        if (Objects.nonNull(envienceFileUrl12)) {
                            //佐证文件访问地址
                            map.put("envienceFileUrl", envienceFileUrl12.toString());
                        }
                        Integer auditStatus12 = each.getAuditStatus();
                        //是否审核
                        switch (auditStatus12) {
                            case 1:
                                map.put("auditStatusCn", "审核通过");
                                break;
                            case 2:
                                map.put("auditStatusCn", "审核不通过");
                                break;
                            case 0:
                            default:
                                map.put("auditStatusCn", "未审核");
                                break;
                        }
                        map.put("uploadMonthText", "十二月份");
                        map.put("auditStatus", auditStatus12);
                    }
                    //主键
                    map.put("id", each.getId());
                    //机构名称
                    map.put("org_name",
                            obj
                                .get("org_name")
                                .toString());
                    //机构主键
                    map.put("org_id",
                            obj
                                .get("org_id")
                                .toString());
                    //筛查年度
                    map.put("upload_year",
                            obj
                                .get("upload_year")
                                .toString());
                    list.add(map);
                });
        }
        hashMap.put("dataMap", list);
        return hashMap;
    }

    /**
     * 本月或上月第一天00:00:00 flag=1--本月 flag=2--上月 getFirstDay()
     *
     * @param flag
     * @return
     */
    public static Date getFirstDay(Integer flag) {
        Calendar c = Calendar.getInstance();
        if (flag == 1) {
            c.add(Calendar.MONTH, 0); //获取当前月第一天
        } else if (flag == 2) {
            c.add(Calendar.MONTH, -1); //获取上月第一天
        }
        c.set(Calendar.DAY_OF_MONTH, 1); //设置为1号,当前日期既为本月第一天
        c.set(Calendar.HOUR_OF_DAY, 0); //将小时至0
        c.set(Calendar.MINUTE, 0); //将分钟至0
        c.set(Calendar.SECOND, 0); //将秒至0
        c.set(Calendar.MILLISECOND, 0); //将毫秒至0
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //return  sdf.format(c.getTime());
        return c.getTime();
    }

    private static boolean isDate(String date) {
        try {
            LocalDate.parse(date, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}
